1. Technical Field
The present disclosure relates to communicating events between applications, and more particularly, to communicating events between a host application and one or more embedded applications therein.
2. Description of the Related Art
Event-driven applications wait for a user's actions or changes in a system (collectively known as “events”) prior to performing an operation. Typically, events are raised or triggered by code running in an application while event listeners or subscribers listen for these events and may execute operations in response to the events detected.
An event aggregator, such as an event sink, contains the logic for managing event subscriptions and event publications. Event aggregators may be utilized for routing events from event sources, such as event publishers, to its subscribers. Managing event subscriptions may include monitoring, tracking, adding and/or removing subscribers.
Event sources or publishers raise or trigger an event to occur in an application. For example, an event source may be code that triggers an event by executing code on or belonging to an event source data object. The data object may be, for example, an element in a graphical user interface of the application such as a button, a textbox, or a link. The event source may notify the subscribers of the application of the triggered events, and a subscriber may perform a specific operation or a program function in response to the raised event. For example, the publisher may notify subscribers of an application of changes entered in a document, and a subscriber may use the notification raised by the event source to trigger another event, such as saving the changes to a memory of the computing system, updating a database entry with the changes raised, or other like events.
Existing event-driven applications may be written in more than one programming language and may have different technologies that lie therein. Thus, it is sometimes challenging to embed one application into another application. For example, when an application written for the web is integrated into a desktop application, the web application may not be able to communicate well with the desktop application from which it is hosted since web applications are typically written in a different programming language and/or utilize a different technology to those of desktop applications. Sometimes an event that occurs may need to be acted upon by both the host application and the embedded application, regardless of the code space from which the event has been triggered. Code space, as used herein, includes a set of computer instructions resident in memory that is managed by an application. Regardless of whether the host and embedded applications share the same technology or language, there may be issues, inefficiencies and/or difficulties in communicating the event between both applications. In current systems, an application may also have at least one application embedded therein, thereby increasing the possibility of miscommunication.
Accordingly, there is a need for a system and methods of communicating an event between a host application and its embedded application(s). There is also a need for a method for more efficiently triggering an event from the host application to the embedded application(s) and vice-versa.